/*
 * jQuery Migrate - v3.0.0 - 2016-06-09
 * Copyright jQuery Foundation and other contributors
 */
(function (c, y) {
    c.migrateVersion = "3.0.0";
    (function () {
        var z = y.console && y.console.log && function () {
            y.console.log.apply(y.console, arguments)
        }, A = /^[12]\./;
        if (!z) {
            return
        }
        if (!c || A.test(c.fn.jquery)) {
            z("JQMIGRATE: jQuery 3.0.0+ REQUIRED")
        }
        if (c.migrateWarnings) {
            z("JQMIGRATE: Migrate plugin loaded multiple times")
        }
        z("JQMIGRATE: Migrate is installed" + (c.migrateMute ? "" : " with logging active") + ", version " + c.migrateVersion)
    })();
    var x = {};
    c.migrateWarnings = [];
    if (c.migrateTrace === undefined) {
        c.migrateTrace = true
    }
    c.migrateReset = function () {
        x = {};
        c.migrateWarnings.length = 0
    };

    function d(A) {
        var z = y.console;
        if (!x[A]) {
            x[A] = true;
            c.migrateWarnings.push(A);
            if (z && z.warn && !c.migrateMute) {
                z.warn("JQMIGRATE: " + A);
                if (c.migrateTrace && z.trace) {
                    z.trace()
                }
            }
        }
    }

    function e(A, B, C, z) {
        Object.defineProperty(A, B, {
            configurable: true, enumerable: true, get: function () {
                d(z);
                return C
            }
        })
    }

    if (document.compatMode === "BackCompat") {
        d("jQuery is not compatible with Quirks Mode")
    }
    var j = c.fn.init, k = c.isNumeric, i = c.find, u = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/,
        t = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g;
    c.fn.init = function (z) {
        var A = Array.prototype.slice.call(arguments);
        if (typeof z === "string" && z === "#") {
            d("jQuery( '#' ) is not a valid selector");
            A[0] = []
        }
        return j.apply(this, A)
    };
    c.fn.init.prototype = c.fn;
    c.find = function (C) {
        var z = Array.prototype.slice.call(arguments);
        if (typeof C === "string" && u.test(C)) {
            try {
                document.querySelector(C)
            } catch (A) {
                C = C.replace(t, function (D, E, F, G) {
                    return "[" + E + F + '"' + G + '"]'
                });
                try {
                    document.querySelector(C);
                    d("Attribute selector with '#' must be quoted: " + z[0]);
                    z[0] = C
                } catch (B) {
                    d("Attribute selector with '#' was not fixed: " + z[0])
                }
            }
        }
        return i.apply(this, z)
    };
    var a;
    for (a in i) {
        if (Object.prototype.hasOwnProperty.call(i, a)) {
            c.find[a] = i[a]
        }
    }
    c.fn.size = function () {
        d("jQuery.fn.size() is deprecated; use the .length property");
        return this.length
    };
    c.parseJSON = function () {
        d("jQuery.parseJSON is deprecated; use JSON.parse");
        return JSON.parse.apply(null, arguments)
    };
    c.isNumeric = function (C) {
        function z(D) {
            var E = D && D.toString();
            return !c.isArray(D) && (E - parseFloat(E) + 1) >= 0
        }

        var A = k(C), B = z(C);
        if (A !== B) {
            d("jQuery.isNumeric() should not be called on constructed objects")
        }
        return B
    };
    e(c, "unique", c.uniqueSort, "jQuery.unique is deprecated, use jQuery.uniqueSort");
    e(c.expr, "filters", c.expr.pseudos, "jQuery.expr.filters is now jQuery.expr.pseudos");
    e(c.expr, ":", c.expr.pseudos, 'jQuery.expr[":"] is now jQuery.expr.pseudos');
    var f = c.ajax;
    c.ajax = function () {
        var z = f.apply(this, arguments);
        if (z.promise) {
            e(z, "success", z.done, "jQXHR.success is deprecated and removed");
            e(z, "error", z.fail, "jQXHR.error is deprecated and removed");
            e(z, "complete", z.always, "jQXHR.complete is deprecated and removed")
        }
        return z
    };
    var o = c.fn.removeAttr, q = c.fn.toggleClass, v = /\S+/g;
    c.fn.removeAttr = function (z) {
        var A = this;
        c.each(z.match(v), function (C, B) {
            if (c.expr.match.bool.test(B)) {
                d("jQuery.fn.removeAttr no longer sets boolean properties: " + B);
                A.prop(B, false)
            }
        });
        return o.apply(this, arguments)
    };
    c.fn.toggleClass = function (z) {
        if (z !== undefined && typeof z !== "boolean") {
            return q.apply(this, arguments)
        }
        d("jQuery.fn.toggleClass( boolean ) is deprecated");
        return this.each(function () {
            var A = this.getAttribute && this.getAttribute("class") || "";
            if (A) {
                c.data(this, "__className__", A)
            }
            if (this.setAttribute) {
                this.setAttribute("class", A || z === false ? "" : c.data(this, "__className__") || "")
            }
        })
    };
    var b = false;
    if (c.swap) {
        c.each(["height", "width", "reliableMarginRight"], function (z, A) {
            var B = c.cssHooks[A] && c.cssHooks[A].get;
            if (B) {
                c.cssHooks[A].get = function () {
                    var C;
                    b = true;
                    C = B.apply(this, arguments);
                    b = false;
                    return C
                }
            }
        })
    }
    c.swap = function (B, E, A, z) {
        var F, C, D = {};
        if (!b) {
            d("jQuery.swap() is undocumented and deprecated")
        }
        for (C in E) {
            D[C] = B.style[C];
            B.style[C] = E[C]
        }
        F = A.apply(B, z || []);
        for (C in E) {
            B.style[C] = D[C]
        }
        return F
    };
    var g = c.data;
    c.data = function (A, B, C) {
        var z;
        if (B && B !== c.camelCase(B)) {
            z = c.hasData(A) && g.call(this, A);
            if (z && B in z) {
                d("jQuery.data() always sets/gets camelCased names: " + B);
                if (arguments.length > 2) {
                    z[B] = C
                }
                return z[B]
            }
        }
        return g.apply(this, arguments)
    };
    var r = c.Tween.prototype.run;
    c.Tween.prototype.run = function (z) {
        if (c.easing[this.easing].length > 1) {
            d('easing function "jQuery.easing.' + this.easing.toString() + '" should use only first argument');
            c.easing[this.easing] = c.easing[this.easing].bind(c.easing, z, this.options.duration * z, 0, 1, this.options.duration)
        }
        r.apply(this, arguments)
    };
    var l = c.fn.load, s = c.event.fix;
    c.event.props = [];
    c.event.fixHooks = {};
    c.event.fix = function (B) {
        var z, D = B.type, A = this.fixHooks[D], C = c.event.props;
        if (C.length) {
            d("jQuery.event.props are deprecated and removed: " + C.join());
            while (C.length) {
                c.event.addProp(C.pop())
            }
        }
        if (A && !A._migrated_) {
            A._migrated_ = true;
            d("jQuery.event.fixHooks are deprecated and removed: " + D);
            if ((C = A.props) && C.length) {
                while (C.length) {
                    c.event.addProp(C.pop())
                }
            }
        }
        z = s.call(this, B);
        return A && A.filter ? A.filter(z, B) : z
    };
    c.each(["load", "unload", "error"], function (z, A) {
        c.fn[A] = function () {
            var B = Array.prototype.slice.call(arguments, 0);
            if (A === "load" && typeof B[0] === "string") {
                return l.apply(this, B)
            }
            d("jQuery.fn." + A + "() is deprecated");
            B.splice(0, 0, A);
            if (arguments.length) {
                return this.on.apply(this, B)
            }
            this.triggerHandler.apply(this, B);
            return this
        }
    });
    c(function () {
        c(document).triggerHandler("ready")
    });
    c.event.special.ready = {
        setup: function () {
            if (this === document) {
                d("'ready' event is deprecated")
            }
        }
    };
    c.fn.extend({
        bind: function (B, z, A) {
            d("jQuery.fn.bind() is deprecated");
            return this.on(B, null, z, A)
        }, unbind: function (A, z) {
            d("jQuery.fn.unbind() is deprecated");
            return this.off(A, null, z)
        }, delegate: function (B, C, z, A) {
            d("jQuery.fn.delegate() is deprecated");
            return this.on(C, B, z, A)
        }, undelegate: function (A, B, z) {
            d("jQuery.fn.undelegate() is deprecated");
            return arguments.length === 1 ? this.off(A, "**") : this.off(B, A || "**", z)
        }
    });
    var m = c.fn.offset;
    c.fn.offset = function () {
        var z, A = this[0], B = {top: 0, left: 0};
        if (!A || !A.nodeType) {
            d("jQuery.fn.offset() requires a valid DOM element");
            return B
        }
        z = (A.ownerDocument || document).documentElement;
        if (!c.contains(z, A)) {
            d("jQuery.fn.offset() requires an element connected to a document");
            return B
        }
        return m.apply(this, arguments)
    };
    var n = c.param;
    c.param = function (A, B) {
        var z = c.ajaxSettings && c.ajaxSettings.traditional;
        if (B === undefined && z) {
            d("jQuery.param() no longer uses jQuery.ajaxSettings.traditional");
            B = z
        }
        return n.call(this, A, B)
    };
    var p = c.fn.andSelf || c.fn.addBack;
    c.fn.andSelf = function () {
        d("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()");
        return p.apply(this, arguments)
    };
    var h = c.Deferred,
        w = [["resolve", "done", c.Callbacks("once memory"), c.Callbacks("once memory"), "resolved"], ["reject", "fail", c.Callbacks("once memory"), c.Callbacks("once memory"), "rejected"], ["notify", "progress", c.Callbacks("memory"), c.Callbacks("memory")]];
    c.Deferred = function (A) {
        var z = h(), B = z.promise();
        z.pipe = B.pipe = function () {
            var C = arguments;
            d("deferred.pipe() is deprecated");
            return c.Deferred(function (D) {
                c.each(w, function (F, G) {
                    var E = c.isFunction(C[F]) && C[F];
                    z[G[1]](function () {
                        var H = E && E.apply(this, arguments);
                        if (H && c.isFunction(H.promise)) {
                            H.promise().done(D.resolve).fail(D.reject).progress(D.notify)
                        } else {
                            D[G[0] + "With"](this === B ? D.promise() : this, E ? [H] : arguments)
                        }
                    })
                });
                C = null
            }).promise()
        };
        if (A) {
            A.call(z, z)
        }
        return z
    }
})(jQuery, window);